home *** CD-ROM | disk | FTP | other *** search
/ GFX Sensations 1 / Graphic Sensations - Volume 1.iso / tools / amiga / 3d_tools / irit40s.lha / Irit / cagd_lib / bsp_read.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-30  |  12.1 KB  |  398 lines
  1. /******************************************************************************
  2. * Bsp-Read.c - Bspline handling routines - read from file.              *
  3. *******************************************************************************
  4. * Written by Gershon Elber, Aug. 90.                          *
  5. ******************************************************************************/
  6.  
  7. #include <ctype.h>
  8. #include <stdio.h>
  9. #include <string.h>
  10. #include "cagd_loc.h"
  11.  
  12. /******************************************************************************
  13. * Reads and returns a bspline curve.                          *
  14. * If error is found in reading the file, ErrStr is set to string describing   *
  15. * it and Line to the line it occured in file.                      *
  16. * If no error is detected *ErrStr = NULL.                      *
  17. ******************************************************************************/
  18. CagdCrvStruct *BspCrvReadFromFile(char *FileName, char **ErrStr, int *ErrLine)
  19. {
  20.     FILE *f;
  21.     char StringToken[LINE_LEN];
  22.     CagdCrvStruct *Crv,
  23.     *CrvTail = NULL,
  24.     *CrvList = NULL;
  25.  
  26.     if ((f = fopen(FileName, "r")) == NULL) {
  27.     *ErrStr = "File not found";
  28.     return NULL;
  29.     }
  30.  
  31.     while (_CagdGetToken(f, StringToken) == TOKEN_OPEN_PAREN) {
  32.     _CagdUnGetToken(StringToken);
  33.         Crv = BspCrvReadFromFile2(f, FALSE, ErrStr, ErrLine);
  34.  
  35.     if (CrvList == NULL)
  36.         CrvList = CrvTail = Crv;
  37.     else {
  38.         CrvTail -> Pnext = Crv;
  39.         CrvTail = Crv;
  40.     }
  41.     }
  42.  
  43.     fclose(f);
  44.  
  45.     return CrvList;
  46. }
  47.  
  48. /******************************************************************************
  49. * Reads and returns a bspline curve.                          *
  50. * If NameWasRead is TRUE, it is assumed prefix "[CURVE BSPLINE" has already   *
  51. * been read. This is useful for a global parser which invokes this routine.   *
  52. * For exactly this reason, the file is NOT closed in the end.              *
  53. * If error is found in reading the file, ErrStr is set to string describing   *
  54. * it and ErrLine to line it occured in file relative to begining of curve.    *
  55. * If no error is detected *ErrStr is set to NULL.                  *
  56. ******************************************************************************/
  57. CagdCrvStruct *BspCrvReadFromFile2(FILE *f, CagdBType NameWasRead,
  58.                         char **ErrStr, int *ErrLine)
  59. {
  60.     CagdPointType PType;
  61.     TokenNumType Token;
  62.     int i, j, Length, Order, MaxCoord;
  63.     char StringToken[LINE_LEN];
  64.     CagdCrvStruct *NewCrv;
  65.  
  66.     _CagdGlblLineCount = *ErrLine;
  67.  
  68.     if (!NameWasRead) {
  69.     while ((Token = _CagdGetToken(f, StringToken)) != TOKEN_EOF &&
  70.            Token != TOKEN_OPEN_PAREN);
  71.  
  72.     /* We found beginning of definition - read one: */
  73.     if (_CagdGetToken(f, StringToken) != TOKEN_CURVE ||
  74.         _CagdGetToken(f, StringToken) != TOKEN_BSPLINE) {
  75.             *ErrStr = "CURVE BSPLINE key words expected";
  76.         *ErrLine = _CagdGlblLineCount;
  77.         return NULL;
  78.     }
  79.     }
  80.  
  81.     if ((Token = _CagdGetToken(f, StringToken)) == TOKEN_OPEN_PAREN) {
  82.     if ((*ErrStr = _CagdGetCurveAttributes(f)) != NULL) {
  83.             *ErrStr = "\"[\" expected";
  84.         *ErrLine = _CagdGlblLineCount;
  85.         return NULL;
  86.     }
  87.     }
  88.     else
  89.     _CagdUnGetToken(StringToken);
  90.  
  91.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  92.     sscanf(StringToken, "%d", &Length) != 1) {
  93.     *ErrStr = "BSPLINE Number of points expected";
  94.     *ErrLine = _CagdGlblLineCount;
  95.     return NULL;
  96.     }
  97.  
  98.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  99.     sscanf(StringToken, "%d", &Order) != 1) {
  100.     *ErrStr = "BSPLINE Order expected";
  101.     *ErrLine = _CagdGlblLineCount;
  102.     return NULL;
  103.     }
  104.  
  105.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  106.     strlen(StringToken) != 2 ||
  107.     (StringToken[0] != 'E' && StringToken[0] != 'P') ||
  108.     !isdigit(StringToken[1]) ||
  109.     atoi(&StringToken[1]) > CAGD_MAX_PT_COORD) {
  110.     *ErrStr = "BSPLINE Point type expected";
  111.     *ErrLine = _CagdGlblLineCount;
  112.     return NULL;
  113.     }
  114.  
  115.     PType = CAGD_MAKE_PT_TYPE(StringToken[0] == 'P', atoi(&StringToken[1]));
  116.  
  117.     NewCrv = BspCrvNew(Length, Order, PType);
  118.  
  119.     /* Read the knot vector first: */
  120.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OPEN_PAREN) {
  121.     *ErrStr = "\"[\" expected";
  122.     *ErrLine = _CagdGlblLineCount;
  123.     CagdCrvFree(NewCrv);
  124.     return NULL;
  125.     }
  126.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_KV) {
  127.     *ErrStr = "KV expected";
  128.     *ErrLine = _CagdGlblLineCount;
  129.     CagdCrvFree(NewCrv);
  130.     return NULL;
  131.     }
  132.     for (i = 0; i < Order + Length; i++) {
  133.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  134.         sscanf(StringToken, CAGD_FLOAT_READ,
  135.                          &NewCrv -> KnotVector[i]) != 1) {
  136.         *ErrStr = "Numeric data expected";
  137.         *ErrLine = _CagdGlblLineCount;
  138.         CagdCrvFree(NewCrv);
  139.         return NULL;
  140.     }
  141.     }
  142.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  143.     *ErrStr = "\"]\" expected";
  144.     *ErrLine = _CagdGlblLineCount;
  145.     CagdCrvFree(NewCrv);
  146.     return NULL;
  147.     }
  148.  
  149.     /* Read the points themselves: */
  150.     MaxCoord = CAGD_NUM_OF_PT_COORD(PType);
  151.     for (i = 0; i < Length; i++) {
  152.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OPEN_PAREN) {
  153.         *ErrStr = "\"[\" expected";
  154.         *ErrLine = _CagdGlblLineCount;
  155.         CagdCrvFree(NewCrv);
  156.         return NULL;
  157.     }
  158.     if (CAGD_IS_RATIONAL_PT(PType)) {
  159.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  160.         sscanf(StringToken, CAGD_FLOAT_READ,
  161.                            &NewCrv -> Points[W][i]) != 1) {
  162.         *ErrStr = "Numeric data expected";
  163.         *ErrLine = _CagdGlblLineCount;
  164.         CagdCrvFree(NewCrv);
  165.         return NULL;
  166.         }
  167.     }
  168.     for (j = 1; j <= MaxCoord; j++) {
  169.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  170.         sscanf(StringToken, CAGD_FLOAT_READ,
  171.                         &NewCrv -> Points[j][i]) != 1) {
  172.         *ErrStr = "Numeric data expected";
  173.         *ErrLine = _CagdGlblLineCount;
  174.         CagdCrvFree(NewCrv);
  175.         return NULL;
  176.         }
  177.     }
  178.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  179.         *ErrStr = "\"]\" expected";
  180.         *ErrLine = _CagdGlblLineCount;
  181.         CagdCrvFree(NewCrv);
  182.         return NULL;
  183.     }
  184.     }
  185.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  186.     *ErrStr = "\"]\" expected";
  187.     *ErrLine = _CagdGlblLineCount;
  188.     CagdCrvFree(NewCrv);
  189.     return NULL;
  190.     }
  191.  
  192.     *ErrLine = _CagdGlblLineCount;
  193.     *ErrStr = NULL;
  194.  
  195.     return NewCrv;
  196. }
  197.  
  198. /******************************************************************************
  199. * Reads and returns a bspline surface.                          *
  200. * If error is found in reading the file, ErrStr is set to string describing   *
  201. * it and Line to the line it occured in file.                      *
  202. * If no error is detected *ErrStr = NULL.                      *
  203. ******************************************************************************/
  204. CagdSrfStruct *BspSrfReadFromFile(char *FileName, char **ErrStr, int *ErrLine)
  205. {
  206.     FILE *f;
  207.     char StringToken[LINE_LEN];
  208.     CagdSrfStruct *Srf,
  209.     *SrfTail = NULL,
  210.     *SrfList = NULL;
  211.  
  212.     if ((f = fopen(FileName, "r")) == NULL) {
  213.     *ErrStr = "File not found";
  214.     return NULL;
  215.     }
  216.  
  217.     while (_CagdGetToken(f, StringToken) == TOKEN_OPEN_PAREN) {
  218.     _CagdUnGetToken(StringToken);
  219.         Srf = BspSrfReadFromFile2(f, FALSE, ErrStr, ErrLine);
  220.  
  221.     if (SrfList == NULL)
  222.         SrfList = SrfTail = Srf;
  223.     else {
  224.         SrfTail -> Pnext = Srf;
  225.         SrfTail = Srf;
  226.     }
  227.     }
  228.  
  229.     fclose(f);
  230.  
  231.     return SrfList;
  232. }
  233.  
  234. /******************************************************************************
  235. * Reads and returns a bspline surface.                          *
  236. * If NameWasRead is TRUE, it is assumed prefix "[SURFACE BSPLINE" has already *
  237. * been read. This is useful for a global parser which invokes this routine.   *
  238. * For exactly this reason, the file is NOT closed in the end.              *
  239. * If error is found in reading the file, ErrStr is set to string describing   *
  240. * it and ErrLine to the line it occured in file.                    *
  241. * If no error is detected *ErrStr = NULL.                      *
  242. ******************************************************************************/
  243. CagdSrfStruct *BspSrfReadFromFile2(FILE *f, CagdBType NameWasRead,
  244.                         char **ErrStr, int *ErrLine)
  245. {
  246.     int i, j, k, Len, ULength, VLength, UOrder, VOrder, MaxCoord;
  247.     char StringToken[LINE_LEN];
  248.     CagdRType *KnotVector;
  249.     CagdPointType PType;
  250.     TokenNumType Token;
  251.     CagdSrfStruct *NewSrf;
  252.  
  253.     _CagdGlblLineCount = *ErrLine;
  254.  
  255.     if (!NameWasRead) {
  256.     while ((Token = _CagdGetToken(f, StringToken)) != TOKEN_EOF &&
  257.            Token != TOKEN_OPEN_PAREN);
  258.  
  259.     /* We found beginning of definition - read one: */
  260.     if (_CagdGetToken(f, StringToken) != TOKEN_SURFACE ||
  261.         _CagdGetToken(f, StringToken) != TOKEN_BSPLINE) {
  262.         *ErrStr = "SURFACE BSPLINE key words expected";
  263.         *ErrLine = _CagdGlblLineCount;
  264.         return NULL;
  265.         }
  266.     }
  267.  
  268.     if ((Token = _CagdGetToken(f, StringToken)) == TOKEN_OPEN_PAREN) {
  269.     if ((*ErrStr = _CagdGetSurfaceAttributes(f)) != NULL) {
  270.         *ErrStr = "\"[\" expected";
  271.         *ErrLine = _CagdGlblLineCount;
  272.         return NULL;
  273.     }
  274.     }
  275.     else
  276.     _CagdUnGetToken(StringToken);
  277.  
  278.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  279.         sscanf(StringToken, "%d", &ULength) != 1 ||
  280.     (Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  281.     sscanf(StringToken, "%d", &VLength) != 1) {
  282.     *ErrStr = "BSPLINE Number of points expected";
  283.     *ErrLine = _CagdGlblLineCount;
  284.     return NULL;
  285.     }
  286.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  287.     sscanf(StringToken, "%d", &UOrder) != 1 ||
  288.     (Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  289.     sscanf(StringToken, "%d", &VOrder) != 1) {
  290.     *ErrStr = "BSPLINE Order expected";
  291.     *ErrLine = _CagdGlblLineCount;
  292.     return NULL;
  293.     }
  294.  
  295.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  296.         strlen(StringToken) != 2 ||
  297.     (StringToken[0] != 'E' && StringToken[0] != 'P') ||
  298.     !isdigit(StringToken[1]) ||
  299.     atoi(&StringToken[1]) > CAGD_MAX_PT_COORD) {
  300.     *ErrStr = "BSPLINE Point type expected";
  301.     *ErrLine = _CagdGlblLineCount;
  302.     return NULL;
  303.     }
  304.     PType = CAGD_MAKE_PT_TYPE(StringToken[0] == 'P', atoi(&StringToken[1]));
  305.  
  306.     NewSrf = BspSrfNew(ULength, VLength, UOrder, VOrder, PType);
  307.  
  308.     /* Read the knot vectors first: */
  309.     for (k = 0; k < 2; k++) {
  310.     if (k == 0) {
  311.         KnotVector = NewSrf -> UKnotVector;
  312.         Len = NewSrf -> UOrder + NewSrf -> ULength;
  313.     }
  314.     else {
  315.         KnotVector = NewSrf -> VKnotVector;
  316.         Len = NewSrf -> VOrder + NewSrf -> VLength;
  317.     }
  318.  
  319.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OPEN_PAREN) {
  320.             *ErrStr = "\"[\" expected";
  321.         *ErrLine = _CagdGlblLineCount;
  322.         CagdSrfFree(NewSrf);
  323.         return NULL;
  324.         }
  325.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_KV) {
  326.         *ErrStr = "KV expected";
  327.         *ErrLine = _CagdGlblLineCount;
  328.         CagdSrfFree(NewSrf);
  329.         return NULL;
  330.     }
  331.  
  332.     for (i = 0; i < Len; i++) {
  333.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  334.             sscanf(StringToken, CAGD_FLOAT_READ, &KnotVector[i]) != 1) {
  335.             *ErrStr = "Numeric data expected";
  336.         *ErrLine = _CagdGlblLineCount;
  337.         CagdSrfFree(NewSrf);
  338.         return NULL;
  339.         }
  340.     }
  341.  
  342.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  343.         *ErrStr = "\"]\" expected";
  344.         *ErrLine = _CagdGlblLineCount;
  345.         CagdSrfFree(NewSrf);
  346.         return NULL;
  347.     }
  348.     }
  349.  
  350.     /* Read the points themselves: */
  351.     MaxCoord = CAGD_NUM_OF_PT_COORD(PType);
  352.     for (i = 0; i < ULength * VLength; i++) {
  353.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OPEN_PAREN) {
  354.         *ErrStr = "\"[\" expected";
  355.         *ErrLine = _CagdGlblLineCount;
  356.         CagdSrfFree(NewSrf);
  357.         return NULL;
  358.     }
  359.     if (CAGD_IS_RATIONAL_PT(PType)) {
  360.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  361.             sscanf(StringToken, CAGD_FLOAT_READ,
  362.                         &NewSrf -> Points[W][i]) != 1) {
  363.         *ErrStr = "Numeric data expected";
  364.         *ErrLine = _CagdGlblLineCount;
  365.         CagdSrfFree(NewSrf);
  366.         return NULL;
  367.         }
  368.     }
  369.     for (j = 1; j <= MaxCoord; j++) {
  370.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  371.             sscanf(StringToken, CAGD_FLOAT_READ,
  372.                         &NewSrf -> Points[j][i]) != 1) {
  373.         *ErrStr = "Numeric data expected";
  374.         *ErrLine = _CagdGlblLineCount;
  375.         CagdSrfFree(NewSrf);
  376.         return NULL;
  377.         }
  378.     }
  379.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  380.         *ErrStr = "\"]\" expected";
  381.         *ErrLine = _CagdGlblLineCount;
  382.         CagdSrfFree(NewSrf);
  383.         return NULL;
  384.     }
  385.     }
  386.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  387.         *ErrStr = "\"]\" expected";
  388.     *ErrLine = _CagdGlblLineCount;
  389.     CagdSrfFree(NewSrf);
  390.     return NULL;
  391.     }
  392.  
  393.     *ErrStr = NULL;
  394.     *ErrLine = _CagdGlblLineCount;
  395.  
  396.     return NewSrf;
  397. }
  398.